/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package pingouin;

import java.awt.Color;
import java.awt.Polygon;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;

/**
 *
 * @author Hippolyte
 */
public class Hexa implements Serializable{

    public int num;
    public int c1, c2, c3, c4, c5, c6;
    public int nbPoisson;
    public HashMap<Integer, Hexa> voisins;
    public int l, c;
    public int xChar;
    public int yChar;
    public int xPingouin;
    public int yPingouin;
    public int xMiddle;
    public int yMiddle;
    public static final int x0 = 0;
    public static final int y0 = 0;
    public static final int lg = 33;
    public static final int miLg = (int) Math.sqrt(lg * lg / 2);
    public static final int dblLg = (int) Math.sqrt(2 * lg * 2 * lg - lg * lg);
    public static final int hauteur = 2 * miLg + lg;
    public static final int largeur = 3 * miLg;
    public static final Color color = Color.BLACK;
    public static final Color FontColor = Color.WHITE;
    
    public static final int LARG_POISSON = 30;
    public static final int HAUT_POISSON = 30;

    public Hexa(int num, int c1, int c2, int c3, int c4, int c5, int c6, int l, int c) {
        this.num = num;
        this.c1 = c1;
        this.c2 = c2;
        this.c3 = c3;
        this.c4 = c4;
        this.c5 = c5;
        this.c6 = c6;
        this.l = l;
        this.c = c;
    }

    public Polygon toPolygon() {

        int x1 = x0 + ((l + 1) % 2) * miLg + c * 2 * miLg;
        int x2 = x0 + ((l + 1) % 2) * miLg + miLg + c * 2 * miLg;
        int x3 = x0 + ((l + 1) % 2) * miLg + 2 * miLg + c * 2 * miLg;
        int x4 = x0 + ((l + 1) % 2) * miLg + 2 * miLg + c * 2 * miLg;
        int x5 = x0 + ((l + 1) % 2) * miLg + miLg + c * 2 * miLg;
        int x6 = x0 + ((l + 1) % 2) * miLg + c * 2 * miLg;

        xMiddle = (x1 + x3) / 2;

        int[] x = {x1, x2, x3, x4, x5, x6};

        int y1 = y0 + miLg + l * dblLg;
        int y2 = y0 + l * dblLg;
        int y3 = y0 + miLg + l * dblLg;
        int y4 = y0 + miLg + lg + l * dblLg;
        int y5 = y0 + 2 * miLg + lg + l * dblLg;
        int y6 = y0 + miLg + lg + l * dblLg;

        yMiddle = (y2 + y5) / 2;

        int[] y = {y1, y2, y3, y4, y5, y6};

        Polygon p = new Polygon(x, y, 6);

        xChar = x0 + ((l + 1) % 2) * miLg + miLg / 2 + c * 2 * miLg;

        yChar = y0 + miLg + lg / 2 + l * dblLg;

        xPingouin = x0 + ((l + 1) % 2) * miLg + miLg / 2 + c * 2 * miLg - Pingouin.RAYON / 4;

        yPingouin = y0 + miLg + l * dblLg - Pingouin.RAYON / 4;

        return p;
    }

    public static Hexa getCase(int num) {
        for (Hexa h : Partie.ressources.hexas) {
            if (h.num == num) {
                return h;
            }
        }
        return null;
    }

    public void setVoisinZero(int num) {
        switch (num) {
            case 1:
                c1 = 0;
            case 2:
                c2 = 0;
            case 3:
                c3 = 0;
            case 4:
                c4 = 0;
            case 5:
                c5 = 0;
            case 6:
                c6 = 0;
        }
    }

    public int getVoisin(int num) {
        switch (num) {
            case 1:
                return c1;
            case 2:
                return c2;
            case 3:
                return c3;
            case 4:
                return c4;
            case 5:
                return c5;
            case 6:
                return c6;
        }
        return -1;
    }

    public ArrayList<Hexa> deplacementsPossibles() {
        ArrayList<Hexa> possibles = new ArrayList<>();

        for (Integer i : voisins.keySet()) {
            if (voisinOk(i)) {
                if (voisins.get(i) != null){
                    possibles.add(voisins.get(i));
                }
                
                Hexa suivant = voisins.get(i);
                while (suivant != null && suivant.voisins.get(i) != null 
                        && suivant.voisins.containsKey(i) && suivant.voisinOk(i)) {

                    if (!possibles.contains(suivant.voisins.get(i))) {
                        possibles.add(suivant.voisins.get(i));
                    }

                    suivant = suivant.voisins.get(i);

                }
            }
        }

        return possibles;
    }
    public ArrayList<Hexa> deplacementsPossibles(Hexa precedent) {
        ArrayList<Hexa> possibles = new ArrayList<>();

        for (Integer i : voisins.keySet()) {
            if (voisinOk(i)) {
                if (voisins.get(i) != null){
                    possibles.add(voisins.get(i));
                }
                
                Hexa suivant = voisins.get(i);
                while (suivant != null && suivant.voisins.get(i) != null 
                        && suivant.voisins.containsKey(i) && suivant.voisinOk(i)
                        && suivant.num != precedent.num) {

                    if (!possibles.contains(suivant.voisins.get(i))) {
                        possibles.add(suivant.voisins.get(i));
                    }

                    suivant = suivant.voisins.get(i);

                }
            }
        }

        return possibles;
    }

    public boolean voisinOk(int num) {

        int voisin = getVoisin(num);

        if (voisin > 0) {
//            if (!Partie.placeLibre(voisin)) {
//                return false;
//            }
//            return (!Partie.ressources.joues.contains(Hexa.getCase(num)));
            return (Partie.placeLibre(voisin));
        }
        return false;
    }

    public ArrayList<Hexa> getVoisinOk() {
        ArrayList<Hexa> possibles = new ArrayList<>();

        for (Integer i : voisins.keySet()) {
            if (voisinOk(i)) {
                possibles.add(voisins.get(i));
            }
        }

        return possibles;
    }

    public void setVoisinAuto() {

        voisins = new HashMap<>();

        if (voisinOk(1)) {
            voisins.put(1, getCase(c1));
        }
        if (voisinOk(2)) {
            voisins.put(2, getCase(c2));
        }
        if (voisinOk(3)) {
            voisins.put(3, getCase(c3));
        }
        if (voisinOk(4)) {
            voisins.put(4, getCase(c4));
        }
        if (voisinOk(5)) {
            voisins.put(5, getCase(c5));
        }
        if (voisinOk(6)) {
            voisins.put(6, getCase(c6));
        }
    }

    public static Hexa findHexa(int xFound, int yFound) {
        
        System.out.println("largeur + hauteur ==> " + (largeur + hauteur) / 4);
        
        Hexa min = null;
        int diffMin = 99999, diffTemp;
        for (Hexa h : Partie.ressources.hexas) {
            diffTemp = Math.abs(xFound - h.xMiddle) + Math.abs(yFound - h.yMiddle);
            if (diffTemp < diffMin && diffTemp < (largeur + hauteur)  / 4) {
                System.out.println("difftemp ==> " + diffTemp);
                min = h;
                diffMin = diffTemp;
            }
        }
        return min;
    }
}
